},
logError(s) {
- log('ERROR: ' + s);
+ log(`ERROR: ${s}`);
},
userdatadir: GLib.build_filenamev([GLib.get_user_data_dir(), 'gnome-shell'])
try {
self.init(null);
} catch (e) {
- log('Failed to connect to Fprint service: ' + e.message);
+ log(`Failed to connect to Fprint service: ${e.message}`);
return null;
}
this._settings = new Gio.Settings({ schema_id: GdmUtil.LOGIN_SCREEN_SCHEMA });
- this._settings.connect('changed::' + GdmUtil.BANNER_MESSAGE_KEY,
+ this._settings.connect(`changed::${GdmUtil.BANNER_MESSAGE_KEY}`,
this._updateBanner.bind(this));
- this._settings.connect('changed::' + GdmUtil.BANNER_MESSAGE_TEXT_KEY,
+ this._settings.connect(`changed::${GdmUtil.BANNER_MESSAGE_TEXT_KEY}`,
this._updateBanner.bind(this));
- this._settings.connect('changed::' + GdmUtil.DISABLE_USER_LIST_KEY,
+ this._settings.connect(`changed::${GdmUtil.DISABLE_USER_LIST_KEY}`,
this._updateDisableUserList.bind(this));
- this._settings.connect('changed::' + GdmUtil.LOGO_KEY,
+ this._settings.connect(`changed::${GdmUtil.LOGO_KEY}`,
this._updateLogo.bind(this));
this._textureCache = St.TextureCache.get_default();
if (metadataContents instanceof Uint8Array)
metadataContents = imports.byteArray.toString(metadataContents);
} catch (e) {
- throw new Error('Failed to load metadata.json: ' + e);
+ throw new Error(`Failed to load metadata.json: ${e}`);
}
let meta;
try {
meta = JSON.parse(metadataContents);
} catch (e) {
- throw new Error('Failed to parse metadata.json: ' + e);
+ throw new Error(`Failed to parse metadata.json: ${e}`);
}
let requiredProperties = ['uuid', 'name', 'description', 'shell-version'];
for (let i = 0; i < requiredProperties.length; i++) {
let prop = requiredProperties[i];
if (!meta[prop]) {
- throw new Error('missing "' + prop + '" property in metadata.json');
+ throw new Error(`missing "${prop}" property in metadata.json`);
}
}
if (uuid != meta.uuid) {
- throw new Error('uuid "' + meta.uuid + '" from metadata.json does not match directory name "' + uuid + '"');
+ throw new Error(`uuid "${meta.uuid}" from metadata.json does not match directory name "${uuid}"`);
}
let extension = {};
else
xml = bytes.toString();
} catch (e) {
- log('Failed to load D-Bus interface ' + iface);
+ log(`Failed to load D-Bus interface ${iface}`);
}
return xml;
this._historyIndex = 0;
if (this._key) {
this._history = global.settings.get_strv(this._key);
- global.settings.connect('changed::' + this._key,
+ global.settings.connect(`changed::${this._key}`,
this._historyChanged.bind(this));
} else {
Gio.Subprocess.new(['ibus-daemon', '--xim', '--panel', 'disable'],
Gio.SubprocessFlags.NONE);
} catch (e) {
- log('Failed to launch ibus-daemon: ' + e.message);
+ log(`Failed to launch ibus-daemon: ${e.message}`);
}
}
let retval = context.process_key_event_async_finish(res);
this.notify_key_event(event, retval);
} catch (e) {
- log('Error processing key on IM: ' + e.message);
+ log(`Error processing key on IM: ${e.message}`);
}
});
return true;
try {
initable.init_finish(result);
} catch (e) {
- logError(e, 'could not initialize proxy for interface ' + interfaceName);
+ logError(e, `could not initialize proxy for interface ${interfaceName}`);
if (onFinished)
onFinished();
try {
initable.init_finish(result);
} catch (e) {
- logError(e, 'could not initialize object manager for object ' + this._serviceName);
+ logError(e, `could not initialize object manager for object ${this._serviceName}`);
this._tryToCompleteLoad();
return;
this._managerProxy.GetManagedObjectsRemote((result, error) => {
if (!result) {
if (error) {
- logError(error, 'could not get remote objects for service ' + this._serviceName + ' path ' + this._managerPath);
+ logError(error, `could not get remote objects for service ${this._serviceName} path ${this._managerPath}`);
}
this._tryToCompleteLoad();
this._userManager.connect('user-removed',
() => this._updateMultiUser());
- this._lockdownSettings.connect('changed::' + DISABLE_USER_SWITCH_KEY,
+ this._lockdownSettings.connect(`changed::${DISABLE_USER_SWITCH_KEY}`,
() => this._updateSwitchUser());
- this._lockdownSettings.connect('changed::' + DISABLE_LOG_OUT_KEY,
+ this._lockdownSettings.connect(`changed::${DISABLE_LOG_OUT_KEY}`,
() => this._updateLogout());
- global.settings.connect('changed::' + ALWAYS_SHOW_LOG_OUT_KEY,
+ global.settings.connect(`changed::${ALWAYS_SHOW_LOG_OUT_KEY}`,
() => this._updateLogout());
- this._lockdownSettings.connect('changed::' + DISABLE_LOCK_SCREEN_KEY,
+ this._lockdownSettings.connect(`changed::${DISABLE_LOCK_SCREEN_KEY}`,
() => this._updateLockScreen());
- this._lockdownSettings.connect('changed::' + DISABLE_LOG_OUT_KEY,
+ this._lockdownSettings.connect(`changed::${DISABLE_LOG_OUT_KEY}`,
() => this._updateHaveShutdown());
this.forceUpdate();
const _notTrailingJunk = '[^\\s`!()\\[\\]{};:\'\\".,<>?\u00AB\u00BB\u201C\u201D\u2018\u2019]';
const _urlRegexp = new RegExp(
- '(^|' + _leadingJunk + ')' +
+ `(^|${_leadingJunk})` +
'(' +
'(?:' +
'(?:http|https|ftp)://' + // scheme://
'(?:' + // one or more:
'[^\\s()<>]+' + // run of non-space non-()
'|' + // or
- _balancedParens + // balanced parens
+ `${_balancedParens}` + // balanced parens
')+' +
'(?:' + // end with:
- _balancedParens + // balanced parens
+ `${_balancedParens}` + // balanced parens
'|' + // or
- _notTrailingJunk + // last non-junk char
+ `${_notTrailingJunk}` + // last non-junk char
')' +
')', 'gi');
} catch (err) {
// Replace "Error invoking GLib.shell_parse_argv: " with
// something nicer
- err.message = err.message.replace(/[^:]*: /, _("Could not parse command:") + "\n");
+ err.message = err.message.replace(/[^:]*: /, `${_("Could not parse command:")}\n`);
throw err;
}
if (!this._settings || handler.id > 0)
return;
- handler.id = this._settings.connect('changed::' + handler.key,
+ handler.id = this._settings.connect(`changed::${handler.key}`,
handler.callback);
handler.callback(this._settings, handler.key);
}
this._weatherAuthorized = false;
this._permStore = new PermissionStore.PermissionStore((proxy, error) => {
if (error) {
- log('Failed to connect to permissionStore: ' + error.message);
+ log(`Failed to connect to permissionStore: ${error.message}`);
return;
}
this._permStore.LookupRemote('gnome', 'geolocation', (res, error) => {
if (error)
- log('Error looking up permission: ' + error.message);
+ log(`Error looking up permission: ${error.message}`);
let [perms, data] = error ? [{}, null] : res;
let params = ['gnome', 'geolocation', false, data, perms];
try {
this._gclueService = Geoclue.Simple.new_finish(res);
} catch (e) {
- log('Failed to connect to Geoclue2 service: ' + e.message);
+ log(`Failed to connect to Geoclue2 service: ${e.message}`);
this._setLocation(this._mostRecentLocation);
return;
}
else
median = Math.round((times[len / 2 - 1] + times[len / 2]) / 2);
- METRICS[timing + 'RedrawTime'].value = median;
+ METRICS[`${timing}RedrawTime`].value = median;
}
}
let [handle, appId, parentWindow, title, subtitle, body, options] = params;
// We probably want to use parentWindow and global.display.focus_window
// for this check in the future
- if (appId && appId + '.desktop' != this._windowTracker.focus_app.id) {
+ if (appId && `${appId}.desktop` != this._windowTracker.focus_app.id) {
invocation.return_error_literal(Gio.DBusError,
Gio.DBusError.ACCESS_DENIED,
'Only the focused app is allowed to show a system access dialog');
if (this._items[id])
this._items[id].actor.navigate_focus(null, St.DirectionType.TAB_FORWARD, false);
else
- log('No such application ' + id);
+ log(`No such application ${id}`);
}
selectApp(id) {
constructor() {
this.FAVORITE_APPS_KEY = 'favorite-apps';
this._favorites = {};
- global.settings.connect('changed::' + this.FAVORITE_APPS_KEY, this._onFavsChanged.bind(this));
+ global.settings.connect(`changed::${this.FAVORITE_APPS_KEY}`, this._onFavsChanged.bind(this));
this.reload();
}
let app = Shell.AppSystem.get_default().lookup_app(desktopFile);
if (!app) {
- log('Settings panel for desktop file ' + desktopFile + ' could not be loaded!');
+ log(`Settings panel for desktop file ${desktopFile} could not be loaded!`);
return;
}
var MESSAGE_ICON_SIZE = -1; // pick up from CSS
-var NC_ = (context, str) => context + '\u0004' + str;
+var NC_ = (context, str) => `${context}\u0004${str}`;
function sameYear(dateA, dateB) {
return (dateA.getYear() == dateB.getYear());
// about the HasCalendars property and would cause an exception trying
// to read it)
} else {
- log('Error loading calendars: ' + e.message);
+ log(`Error loading calendars: ${e.message}`);
return;
}
}
this._weekStart = Shell.util_get_week_start();
this._settings = new Gio.Settings({ schema_id: 'org.gnome.desktop.calendar' });
- this._settings.connect('changed::' + SHOW_WEEKDATE_KEY, this._onSettingsChange.bind(this));
+ this._settings.connect(`changed::${SHOW_WEEKDATE_KEY}`, this._onSettingsChange.bind(this));
this._useWeekdate = this._settings.get_boolean(SHOW_WEEKDATE_KEY);
/**
// Hack used in lieu of border-collapse - see gnome-shell.css
if (row == 2)
- styleClass = 'calendar-day-top ' + styleClass;
+ styleClass = `calendar-day-top ${styleClass}`;
let leftMost = rtl ? iter.getDay() == (this._weekStart + 6) % 7
: iter.getDay() == this._weekStart;
if (leftMost)
- styleClass = 'calendar-day-left ' + styleClass;
+ styleClass = `calendar-day-left ${styleClass}`;
if (sameDay(now, iter))
styleClass += ' calendar-today';
try {
drive.stop_finish(res);
} catch (e) {
- log("Unable to stop the drive after drive-eject-button " + e.toString());
+ log(`Unable to stop the drive after drive-eject-button ${e.toString()}`);
}
});
} else if (drive.can_eject()) {
try {
drive.eject_with_operation_finish(res);
} catch (e) {
- log("Unable to eject the drive after drive-eject-button " + e.toString());
+ log(`Unable to eject the drive after drive-eject-button ${e.toString()}`);
}
});
}
}
if (!e.matches(Gio.IOErrorEnum, Gio.IOErrorEnum.FAILED_HANDLED))
- log('Unable to mount volume ' + volume.get_name() + ': ' + e.toString());
+ log(`Unable to mount volume ${volume.get_name()}: ${e.toString()}`);
this._closeOperation(volume);
}
}
retval = app.launch(files,
global.create_app_launch_context(0, -1));
} catch (e) {
- log('Unable to launch the application ' + app.get_name()
- + ': ' + e.toString());
+ log(`Unable to launch the application ${app.get_name()}: ${e}`);
}
return retval;
try {
contentTypes = mount.guess_content_type_finish(res);
} catch (e) {
- log('Unable to guess content types on added mount ' + mount.get_name()
- + ': ' + e.toString());
+ log(`Unable to guess content types on added mount ${mount.get_name()}: ${e}`);
}
if (contentTypes.length) {
validate: this._validateWpaPsk, password: true });
break;
case 'none': // static WEP
- secrets.push({ label: _("Key: "), key: 'wep-key' + wirelessSecuritySetting.wep_tx_keyidx,
+ secrets.push({ label: _("Key: "), key: `wep-key${wirelessSecuritySetting.wep_tx_keyidx}`,
value: wirelessSecuritySetting.get_wep_key(wirelessSecuritySetting.wep_tx_keyidx) || '',
wep_key_type: wirelessSecuritySetting.wep_key_type,
validate: this._validateStaticWep, password: true });
this._get8021xSecrets(secrets);
break;
default:
- log('Invalid wireless key management: ' + wirelessSecuritySetting.key_mgmt);
+ log(`Invalid wireless key management: ${wirelessSecuritySetting.key_mgmt}`);
}
}
value: ieee8021xSetting.private_key_password || '', password: true });
break;
default:
- log('Invalid EAP/IEEE802.1x method: ' + ieee8021xSetting.get_eap_method(0));
+ log(`Invalid EAP/IEEE802.1x method: ${ieee8021xSetting.get_eap_method(0)}`);
}
}
this._getMobileSecrets(content.secrets, connectionType);
break;
default:
- log('Invalid connection type: ' + connectionType);
+ log(`Invalid connection type: ${connectionType}`);
}
return content;
try {
vpnSetting.foreach_data_item((key, value) => {
- this._stdin.write('DATA_KEY=' + key + '\n', null);
- this._stdin.write('DATA_VAL=' + (value || '') + '\n\n', null);
+ this._stdin.write(`DATA_KEY=${key}\n`, null);
+ this._stdin.write(`DATA_VAL=${value || ''}\n\n`, null);
});
vpnSetting.foreach_secret((key, value) => {
- this._stdin.write('SECRET_KEY=' + key + '\n', null);
- this._stdin.write('SECRET_VAL=' + (value || '') + '\n\n', null);
+ this._stdin.write(`SECRET_KEY=${key}\n`, null);
+ this._stdin.write(`SECRET_VAL=${value || ''}\n\n`, null);
});
this._stdin.write('DONE\n\n', null);
} catch (e) {
let monitor = this._pluginDir.monitor(Gio.FileMonitorFlags.NONE, null);
monitor.connect('changed', () => this._vpnCacheBuilt = false);
} catch (e) {
- log('Failed to create monitor for VPN plugin dir: ' + e.message);
+ log(`Failed to create monitor for VPN plugin dir: ${e.message}`);
}
this._native.connect('new-request', this._newRequest.bind(this));
body = _("A password is required to connect to “%s”.").format(connectionSetting.get_id());
break;
default:
- log('Invalid connection type: ' + connectionType);
+ log(`Invalid connection type: ${connectionType}`);
this._native.respond(requestId, Shell.NetworkAgentResponse.INTERNAL_ERROR);
return;
}
this.contentLayout.add_actor(content);
if (userNames.length > 1) {
- log('polkitAuthenticationAgent: Received ' + userNames.length +
- ' identities that can be used for authentication. Only ' +
+ log(`polkitAuthenticationAgent: Received ${userNames.length} ` +
+ 'identities that can be used for authentication. Only ' +
'considering one.');
}
//
// We could add retrying if this turns out to be a problem
- log('polkitAuthenticationAgent: Failed to show modal dialog.' +
- ' Dismissing authentication request for action-id ' + this.actionId +
- ' cookie ' + this._cookie);
+ log('polkitAuthenticationAgent: Failed to show modal dialog. ' +
+ `Dismissing authentication request for action-id ${this.actionId} ` +
+ `cookie ${this._cookie}`);
this._emitDone(true);
}
}
try {
this._client.register();
} catch (e) {
- throw new Error('Couldn\'t register Telepathy client. Error: \n' + e);
+ throw new Error(`Could not register Telepathy client. Error: ${e}`);
}
if (!this._client.account_manager.is_prepared(Tp.AccountManager.get_feature_quark_core()))
dispatchOp.claim_with_finish(result);
this._handlingChannels(account, conn, [channel], false);
} catch (err) {
- log('Failed to Claim channel: ' + err);
+ log(`Failed to Claim channel: ${err}`);
}
});
let base = origToString.call(this);
try {
if ('actor' in this && this.actor instanceof Clutter.Actor)
- return base.replace(/\]$/, ' delegate for ' + this.actor.toString().substring(1));
+ return base.replace(/\]$/, ` delegate for ${this.actor.toString().substring(1)}`);
else
return base;
} catch (e) {
const ModalDialog = imports.ui.modalDialog;
var REPOSITORY_URL_BASE = 'https://extensions.gnome.org';
-var REPOSITORY_URL_DOWNLOAD = REPOSITORY_URL_BASE + '/download-extension/%s.shell-extension.zip';
-var REPOSITORY_URL_INFO = REPOSITORY_URL_BASE + '/extension-info/';
-var REPOSITORY_URL_UPDATE = REPOSITORY_URL_BASE + '/update-info/';
+var REPOSITORY_URL_DOWNLOAD = `${REPOSITORY_URL_BASE}/download-extension/%s.shell-extension.zip`;
+var REPOSITORY_URL_INFO = `${REPOSITORY_URL_BASE}/extension-info/`;
+var REPOSITORY_URL_UPDATE = `${REPOSITORY_URL_BASE}/update-info/`;
let _httpSession;
_httpSession.queue_message(message, (session, message) => {
if (message.status_code != Soup.KnownStatusCode.OK) {
- ExtensionSystem.logExtensionError(uuid, 'downloading info: ' + message.status_code);
+ ExtensionSystem.logExtensionError(uuid, `downloading info: ${message.status_code}`);
invocation.return_dbus_error('org.gnome.Shell.DownloadInfoError', message.status_code.toString());
return;
}
try {
info = JSON.parse(message.response_body.data);
} catch (e) {
- ExtensionSystem.logExtensionError(uuid, 'parsing info: ' + e);
+ ExtensionSystem.logExtensionError(uuid, `parsing info: ${e}`);
invocation.return_dbus_error('org.gnome.Shell.ParseInfoError', e.toString());
return;
}
function errback(code, message) {
let msg = message ? message.toString() : '';
log('Error while installing %s: %s (%s)'.format(uuid, code, msg));
- invocation.return_dbus_error('org.gnome.Shell.' + code, msg);
+ invocation.return_dbus_error(`org.gnome.Shell.${code}`, msg);
}
function callback() {
extensionOrder.push(uuid);
- let stylesheetNames = [global.session_mode + '.css', 'stylesheet.css'];
+ let stylesheetNames = [`${global.session_mode}.css`, 'stylesheet.css'];
let theme = St.ThemeContext.get_for_stage(global.stage).get_theme();
for (let i = 0; i < stylesheetNames.length; i++) {
try {
}
function _loadExtensions() {
- global.settings.connect('changed::' + ENABLED_EXTENSIONS_KEY, onEnabledExtensionsChanged);
- global.settings.connect('changed::' + DISABLE_USER_EXTENSIONS_KEY, onEnabledExtensionsChanged);
- global.settings.connect('changed::' + EXTENSION_DISABLE_VERSION_CHECK_KEY, _onVersionValidationChanged);
+ global.settings.connect(`changed::${ENABLED_EXTENSIONS_KEY}`, onEnabledExtensionsChanged);
+ global.settings.connect(`changed::${DISABLE_USER_EXTENSIONS_KEY}`, onEnabledExtensionsChanged);
+ global.settings.connect(`changed::${EXTENSION_DISABLE_VERSION_CHECK_KEY}`, _onVersionValidationChanged);
enabledExtensions = getEnabledExtensions();
if (!this._initAtspi() || this._focusListenerRegistered)
return;
- this._atspiListener.register(STATECHANGED + ':focused');
- this._atspiListener.register(STATECHANGED + ':selected');
+ this._atspiListener.register(`${STATECHANGED}:focused`);
+ this._atspiListener.register(`${STATECHANGED}:selected`);
this._focusListenerRegistered = true;
}
if (!this._focusListenerRegistered)
return;
- this._atspiListener.deregister(STATECHANGED + ':focused');
- this._atspiListener.deregister(STATECHANGED + ':selected');
+ this._atspiListener.deregister(`${STATECHANGED}:focused`);
+ this._atspiListener.deregister(`${STATECHANGED}:selected`);
this._focusListenerRegistered = false;
}
this.actor.add(cmdTxt);
let box = new St.BoxLayout({});
this.actor.add(box);
- let resultTxt = new St.Label({ text: 'r(' + index + ') = ' });
+ let resultTxt = new St.Label({ text: `r(${index}) = ` });
resultTxt.clutter_text.ellipsize = Pango.EllipsizeMode.END;
box.add(resultTxt);
let objLink = new ObjLink(this._lookingGlass, o);
box.add(windowLink.actor, { x_align: St.Align.START, x_fill: false });
let propsBox = new St.BoxLayout({ vertical: true, style: 'padding-left: 6px;' });
box.add(propsBox);
- propsBox.add(new St.Label({ text: 'wmclass: ' + metaWindow.get_wm_class() }));
+ propsBox.add(new St.Label({ text: `wmclass: ${metaWindow.get_wm_class()}` }));
let app = tracker.get_window_app(metaWindow);
if (app != null && !app.is_window_backed()) {
let icon = app.create_icon_texture(22);
link = new St.Label({ text: '<error>' });
}
let hbox = new St.BoxLayout();
- hbox.add(new St.Label({ text: propName + ': ' }));
+ hbox.add(new St.Label({ text: `${propName}: ` }));
hbox.add(link);
this._container.add_actor(hbox);
}
this._target = target;
this._pointerTarget = target;
- let position = '[inspect x: ' + stageX + ' y: ' + stageY + ']';
+ let position = `[inspect x: ${stageX} y: ${stageY}]`;
this._displayText.text = '';
- this._displayText.text = position + ' ' + this._target;
+ this._displayText.text = `${position} ${this._target}`;
this._lookingGlass.setBorderPaintTarget(this._target);
}
inspectIcon.connect('button-press-event', () => {
let inspector = new Inspector(this);
inspector.connect('target', (i, target, stageX, stageY) => {
- this._pushResult('inspect(' + Math.round(stageX) + ', ' + Math.round(stageY) + ')', target);
+ this._pushResult(`inspect(${Math.round(stageX)}, ${Math.round(stageY)})`, target);
});
inspector.connect('closed', () => {
this.actor.show();
let fontDesc = Pango.FontDescription.from_string(fontName);
// We ignore everything but size and style; you'd be crazy to set your system-wide
// monospace font to be bold/oblique/etc. Could easily be added here.
- this.actor.style =
- 'font-size: ' + fontDesc.get_size() / 1024. + (fontDesc.get_size_is_absolute() ? 'px' : 'pt') + ';'
- + 'font-family: "' + fontDesc.get_family() + '";';
+ let size = fontDesc.get_size() / 1024.;
+ let unit = fontDesc.get_size_is_absolute() ? 'px' : 'pt';
+ this.actor.style = `
+ font-size: ${size}${unit};
+ font-family: "${fontDesc.get_family()}";`;
}
setBorderPaintTarget(obj) {
try {
resultObj = Function(fullCmd)();
} catch (e) {
- resultObj = '<exception ' + e + '>';
+ resultObj = `<exception ${e}>`;
}
this._pushResult(command, resultObj);
_settingsInit(zoomRegion) {
this._settings = new Gio.Settings({ schema_id: MAGNIFIER_SCHEMA });
- this._settings.connect('changed::' + SCREEN_POSITION_KEY,
+ this._settings.connect(`changed::${SCREEN_POSITION_KEY}`,
this._updateScreenPosition.bind(this));
- this._settings.connect('changed::' + MAG_FACTOR_KEY,
+ this._settings.connect(`changed::${MAG_FACTOR_KEY}`,
this._updateMagFactor.bind(this));
- this._settings.connect('changed::' + LENS_MODE_KEY,
+ this._settings.connect(`changed::${LENS_MODE_KEY}`,
this._updateLensMode.bind(this));
- this._settings.connect('changed::' + CLAMP_MODE_KEY,
+ this._settings.connect(`changed::${CLAMP_MODE_KEY}`,
this._updateClampMode.bind(this));
- this._settings.connect('changed::' + MOUSE_TRACKING_KEY,
+ this._settings.connect(`changed::${MOUSE_TRACKING_KEY}`,
this._updateMouseTrackingMode.bind(this));
- this._settings.connect('changed::' + FOCUS_TRACKING_KEY,
+ this._settings.connect(`changed::${FOCUS_TRACKING_KEY}`,
this._updateFocusTrackingMode.bind(this));
- this._settings.connect('changed::' + CARET_TRACKING_KEY,
+ this._settings.connect(`changed::${CARET_TRACKING_KEY}`,
this._updateCaretTrackingMode.bind(this));
- this._settings.connect('changed::' + INVERT_LIGHTNESS_KEY,
+ this._settings.connect(`changed::${INVERT_LIGHTNESS_KEY}`,
this._updateInvertLightness.bind(this));
- this._settings.connect('changed::' + COLOR_SATURATION_KEY,
+ this._settings.connect(`changed::${COLOR_SATURATION_KEY}`,
this._updateColorSaturation.bind(this));
- this._settings.connect('changed::' + BRIGHT_RED_KEY,
+ this._settings.connect(`changed::${BRIGHT_RED_KEY}`,
this._updateBrightness.bind(this));
- this._settings.connect('changed::' + BRIGHT_GREEN_KEY,
+ this._settings.connect(`changed::${BRIGHT_GREEN_KEY}`,
this._updateBrightness.bind(this));
- this._settings.connect('changed::' + BRIGHT_BLUE_KEY,
+ this._settings.connect(`changed::${BRIGHT_BLUE_KEY}`,
this._updateBrightness.bind(this));
- this._settings.connect('changed::' + CONTRAST_RED_KEY,
+ this._settings.connect(`changed::${CONTRAST_RED_KEY}`,
this._updateContrast.bind(this));
- this._settings.connect('changed::' + CONTRAST_GREEN_KEY,
+ this._settings.connect(`changed::${CONTRAST_GREEN_KEY}`,
this._updateContrast.bind(this));
- this._settings.connect('changed::' + CONTRAST_BLUE_KEY,
+ this._settings.connect(`changed::${CONTRAST_BLUE_KEY}`,
this._updateContrast.bind(this));
- this._settings.connect('changed::' + SHOW_CROSS_HAIRS_KEY, () => {
+ this._settings.connect(`changed::${SHOW_CROSS_HAIRS_KEY}`, () => {
this.setCrosshairsVisible(this._settings.get_boolean(SHOW_CROSS_HAIRS_KEY));
});
- this._settings.connect('changed::' + CROSS_HAIRS_THICKNESS_KEY, () => {
+ this._settings.connect(`changed::${CROSS_HAIRS_THICKNESS_KEY}`, () => {
this.setCrosshairsThickness(this._settings.get_int(CROSS_HAIRS_THICKNESS_KEY));
});
- this._settings.connect('changed::' + CROSS_HAIRS_COLOR_KEY, () => {
+ this._settings.connect(`changed::${CROSS_HAIRS_COLOR_KEY}`, () => {
this.setCrosshairsColor(this._settings.get_string(CROSS_HAIRS_COLOR_KEY));
});
- this._settings.connect('changed::' + CROSS_HAIRS_OPACITY_KEY, () => {
+ this._settings.connect(`changed::${CROSS_HAIRS_OPACITY_KEY}`, () => {
this.setCrosshairsOpacity(this._settings.get_double(CROSS_HAIRS_OPACITY_KEY));
});
- this._settings.connect('changed::' + CROSS_HAIRS_LENGTH_KEY, () => {
+ this._settings.connect(`changed::${CROSS_HAIRS_LENGTH_KEY}`, () => {
this.setCrosshairsLength(this._settings.get_int(CROSS_HAIRS_LENGTH_KEY));
});
- this._settings.connect('changed::' + CROSS_HAIRS_CLIP_KEY, () => {
+ this._settings.connect(`changed::${CROSS_HAIRS_CLIP_KEY}`, () => {
this.setCrosshairsClip(this._settings.get_boolean(CROSS_HAIRS_CLIP_KEY));
});
try {
extents = component.get_extents(Atspi.CoordType.SCREEN);
} catch (e) {
- log('Failed to read extents of focused component: ' + e.message);
+ log(`Failed to read extents of focused component: ${e.message}`);
return;
}
try {
extents = text.get_character_extents(text.get_caret_offset(), 0);
} catch (e) {
- log('Failed to read extents of text caret: ' + e.message);
+ log(`Failed to read extents of text caret: ${e.message}`);
return;
}
let ROI = { x: roi[0], y: roi[1], width: roi[2] - roi[0], height: roi[3] - roi[1] };
let viewBox = { x: viewPort[0], y: viewPort[1], width: viewPort[2] - viewPort[0], height: viewPort[3] - viewPort[1] };
let realZoomRegion = Main.magnifier.createZoomRegion(xMagFactor, yMagFactor, ROI, viewBox);
- let objectPath = ZOOM_SERVICE_PATH + '/zoomer' + _zoomRegionInstanceCount;
+ let objectPath = `${ZOOM_SERVICE_PATH}/zoomer${_zoomRegionInstanceCount}`;
_zoomRegionInstanceCount++;
let zoomRegionProxy = new ShellMagnifierZoomRegion(objectPath, realZoomRegion);
let perfModuleName = GLib.getenv("SHELL_PERF_MODULE");
if (perfModuleName) {
let perfOutput = GLib.getenv("SHELL_PERF_OUTPUT");
- let module = eval('imports.perf.' + perfModuleName + ';');
+ let module = eval(`imports.perf.${perfModuleName};`);
Scripting.runPerfScript(module, perfOutput);
}
});
function notifyError(msg, details) {
// Also print to stderr so it's logged somewhere
if (details)
- log('error: ' + msg + ': ' + details);
+ log(`error: ${msg}: ${details}`);
else
- log('error: ' + msg);
+ log(`error: ${msg}`);
notify(msg, details);
}
this._masterSettings = new Gio.Settings({ schema_id: 'org.gnome.desktop.notifications' });
this._settings = new Gio.Settings({ schema_id: 'org.gnome.desktop.notifications.application',
- path: '/org/gnome/desktop/notifications/application/' + this._canonicalId + '/' });
+ path: `/org/gnome/desktop/notifications/application/${this._canonicalId}/` });
this._masterSettings.connect('changed', this._changed.bind(this));
this._settings.connect('changed', this._changed.bind(this));
}
store() {
- this._settings.set_string('application-id', this.id + '.desktop');
+ this._settings.set_string('application-id', `${this.id}.desktop`);
let apps = this._masterSettings.get_strv('application-children');
if (!apps.includes(this._canonicalId)) {
add(source) {
if (this.contains(source)) {
- log('Trying to re-add source ' + source.title);
+ log(`Trying to re-add source ${source.title}`);
return;
}
// so prefer activating the app via .desktop file if possible
let app = null;
if (this._mprisProxy.DesktopEntry) {
- let desktopId = this._mprisProxy.DesktopEntry + '.desktop';
+ let desktopId = `${this._mprisProxy.DesktopEntry}.desktop`;
app = Shell.AppSystem.get_default().lookup_app(desktopId);
}
return app;
if (appId) {
- app = Shell.AppSystem.get_default().lookup_app(appId + '.desktop');
+ app = Shell.AppSystem.get_default().lookup_app(`${appId}.desktop`);
if (app != null)
return app;
}
}
function getPlatformData() {
- let startupId = GLib.Variant.new('s', '_TIME' + global.get_current_time());
+ let startupId = GLib.Variant.new('s', `_TIME${global.get_current_time()}`);
return { "desktop-startup-id": startupId };
}
if (!GLib.Variant.is_object_path(objectPath))
throw new InvalidAppError();
- let app = Shell.AppSystem.get_default().lookup_app(appId + '.desktop');
+ let app = Shell.AppSystem.get_default().lookup_app(`${appId}.desktop`);
if (!app)
throw new InvalidAppError();
return ('<?xml version="1.0" encoding="UTF-8" standalone="no"?>' +
'<svg version="1.1" xmlns="http://www.w3.org/2000/svg" ' +
'xmlns:xi="http://www.w3.org/2001/XInclude" ' +
- 'width="' + this._imageWidth + '" height="' + this._imageHeight + '"> ' +
+ `width="${this._imageWidth}" height="${this._imageHeight}"> ` +
'<style type="text/css">');
}
for (let i = 0; i < this._activeButtons.length; i++) {
let ch = String.fromCharCode('A'.charCodeAt() + this._activeButtons[i]);
- css += ('.' + ch + ' { ' +
- ' stroke: ' + ACTIVE_COLOR + ' !important; ' +
- ' fill: ' + ACTIVE_COLOR + ' !important; ' +
- '} ');
+ css += `.${ch} {
+ stroke: ${ACTIVE_COLOR} !important;
+ fill: ${ACTIVE_COLOR} !important;
+ }`;
}
return css;
let leaderPos, leaderSize, pos;
let found, direction;
- [found, pos] = this._handle.get_position_sub('#' + labelName);
+ [found, pos] = this._handle.get_position_sub(`#${labelName}`);
if (!found)
return [false];
- [found, leaderPos] = this._handle.get_position_sub('#' + leaderName);
- [found, leaderSize] = this._handle.get_dimensions_sub('#' + leaderName);
+ [found, leaderPos] = this._handle.get_position_sub(`#${leaderName}`);
+ [found, leaderSize] = this._handle.get_dimensions_sub(`#${leaderName}`);
if (!found)
return [false];
getButtonLabelCoords(button) {
let ch = String.fromCharCode('A'.charCodeAt() + button);
- let labelName = 'Label' + ch;
- let leaderName = 'Leader' + ch;
+ let labelName = `Label${ch}`;
+ let leaderName = `Leader${ch}`;
return this._getItemLabelCoords(labelName, leaderName);
}
getRingLabelCoords(number, dir) {
let numStr = number > 0 ? (number + 1).toString() : '';
let dirStr = dir == CW ? 'CW' : 'CCW';
- let labelName = 'LabelRing' + numStr + dirStr;
- let leaderName = 'LeaderRing' + numStr + dirStr;
+ let labelName = `LabelRing${numStr}${dirStr}`;
+ let leaderName = `LeaderRing${numStr}${dirStr}`;
return this._getItemLabelCoords(labelName, leaderName);
}
getStripLabelCoords(number, dir) {
let numStr = number > 0 ? (number + 1).toString() : '';
let dirStr = dir == UP ? 'Up' : 'Down';
- let labelName = 'LabelStrip' + numStr + dirStr;
- let leaderName = 'LeaderStrip' + numStr + dirStr;
+ let labelName = `LabelStrip${numStr}${dirStr}`;
+ let leaderName = `LeaderStrip${numStr}${dirStr}`;
return this._getItemLabelCoords(labelName, leaderName);
}
_startButtonActionEdition(button) {
let ch = String.fromCharCode('A'.charCodeAt() + button);
- let key = 'button' + ch;
+ let key = `button${ch}`;
this._startActionEdition(key, Meta.PadActionType.BUTTON, button);
}
addToStatusArea(role, indicator, position, box) {
if (this.statusArea[role])
- throw new Error('Extension point conflict: there is already a status indicator for role ' + role);
+ throw new Error(`Extension point conflict: there is already a status indicator for role ${role}`);
if (!(indicator instanceof PanelMenu.Button))
throw new TypeError('Status indicator must be an instance of PanelMenu.Button');
let app = Shell.AppSystem.get_default().lookup_app(desktopFile);
if (!app) {
- log('Settings panel for desktop file ' + desktopFile + ' could not be loaded!');
+ log(`Settings panel for desktop file ${desktopFile} could not be loaded!`);
return;
}
if (!appInfo.should_show())
return;
} catch (e) {
- log('Ignoring search provider ' + path + ': missing DesktopId');
+ log(`Ignoring search provider ${path}: missing DesktopId`);
return;
}
launchSearch(terms) {
// the provider is not compatible with the new version of the interface, launch
// the app itself but warn so we can catch the error in logs
- log('Search provider ' + this.appInfo.get_id() + ' does not implement LaunchSearch');
+ log(`Search provider ${this.appInfo.get_id()} does not implement LaunchSearch`);
this.appInfo.launch([], global.create_app_launch_context(0, -1));
}
};
if (inTerminal) {
let exec = this._terminalSettings.get_string(EXEC_KEY);
let execArg = this._terminalSettings.get_string(EXEC_ARG_KEY);
- command = exec + ' ' + execArg + ' ' + input;
+ command = `${exec} ${execArg} ${input}`;
}
Util.trySpawnCommandLine(command);
} catch (e) {
});
this._settings = new Gio.Settings({ schema_id: SCREENSAVER_SCHEMA });
- this._settings.connect('changed::' + LOCK_ENABLED_KEY, this._syncInhibitor.bind(this));
+ this._settings.connect(`changed::${LOCK_ENABLED_KEY}`, this._syncInhibitor.bind(this));
this._lockSettings = new Gio.Settings({ schema_id: LOCKDOWN_SCHEMA });
- this._lockSettings.connect('changed::' + DISABLE_LOCK_KEY, this._syncInhibitor.bind(this));
+ this._lockSettings.connect(`changed::${DISABLE_LOCK_KEY}`, this._syncInhibitor.bind(this));
this._isModal = false;
this._hasLockScreen = false;
* within a performance automation script
*/
function defineScriptEvent(name, description) {
- Shell.PerfLog.get_default().define_event("script." + name,
+ Shell.PerfLog.get_default().define_event(`script.${name}`,
description,
"");
}
* previously defined with defineScriptEvent
*/
function scriptEvent(name) {
- Shell.PerfLog.get_default().event("script." + name);
+ Shell.PerfLog.get_default().event(`script.${name}`);
}
/**
for (let f in scriptModule) {
let m = /([A-Za-z]+)_([A-Za-z]+)/.exec(f);
if (m)
- eventHandlers[m[1] + "." + m[2]] = scriptModule[f];
+ eventHandlers[`${m[1]}.${m[2]}`] = scriptModule[f];
}
Shell.PerfLog.get_default().replay(
// Extra checks here because JSON.stringify generates
// invalid JSON for undefined values
if (metric.description == null) {
- log("Error: No description found for metric " + name);
+ log(`Error: No description found for metric ${name}`);
continue;
}
if (metric.units == null) {
- log("Error: No units found for metric " + name);
+ log(`Error: No units found for metric ${name}`);
continue;
}
if (metric.value == null) {
- log("Error: No value found for metric " + name);
+ log(`Error: No value found for metric ${name}`);
continue;
}
first = false;
Shell.write_string_to_stream(out,
- '{ "name": ' + JSON.stringify(name) + ',\n' +
- ' "description": ' + JSON.stringify(metric.description) + ',\n' +
- ' "units": ' + JSON.stringify(metric.units) + ',\n' +
- ' "value": ' + JSON.stringify(metric.value) + ' }');
+ `{ "name": ${JSON.stringify(name)},\n` +
+ ` "description": ${JSON.stringify(metric.description)},\n` +
+ ` "units": ${JSON.stringify(metric.units)},\n` +
+ ` "value": ${JSON.stringify(metric.value)} }`);
}
Shell.write_string_to_stream(out, ' ]');
print ('------------------------------------------------------------');
for (let i = 0; i < metrics.length; i++) {
let metric = metrics[i];
- print ('# ' + scriptModule.METRICS[metric].description);
- print (metric + ': ' + scriptModule.METRICS[metric].value + scriptModule.METRICS[metric].units);
+ print (`# ${scriptModule.METRICS[metric].description}`);
+ print (`${metric}: ${scriptModule.METRICS[metric].value}${scriptModule.METRICS[metric].units}`);
}
print ('------------------------------------------------------------');
}
return;
}
if (metas.length != metasNeeded.length) {
- log('Wrong number of result metas returned by search provider ' + this.provider.id +
- ': expected ' + metasNeeded.length + ' but got ' + metas.length);
+ log(`Wrong number of result metas returned by search provider ${this.provider.id}: ` +
+ `expected ${metasNeeded.length} but got ${metas.length}`);
callback(false);
return;
}
if (metas.some(meta => !meta.name || !meta.id)) {
- log('Invalid result meta returned from search provider ' + this.provider.id);
+ log(`Invalid result meta returned from search provider ${this.provider.id}`);
callback(false);
return;
}
_setCurrentRequest(invocation, id, type) {
let oldId = this._currentId;
let oldType = this._currentType;
- let requestId = id + '@' + invocation.get_sender();
+ let requestId = `${id}@${invocation.get_sender()}`;
this._clearCurrentRequest(Gio.MountOperationResult.UNHANDLED, {});
this.add_child(this._hbox);
this._a11ySettings = new Gio.Settings({ schema_id: A11Y_SCHEMA });
- this._a11ySettings.connect('changed::' + KEY_ALWAYS_SHOW, this._queueSyncMenuVisibility.bind(this));
+ this._a11ySettings.connect(`changed::${KEY_ALWAYS_SHOW}`, this._queueSyncMenuVisibility.bind(this));
let highContrast = this._buildHCItem();
this.menu.addMenuItem(highContrast);
settings.is_writable(key),
enabled => settings.set_boolean(key, enabled));
- settings.connect('changed::' + key, () => {
+ settings.connect(`changed::${key}`, () => {
widget.setToggleState(settings.get_boolean(key));
this._queueSyncMenuVisibility();
}
});
- interfaceSettings.connect('changed::' + KEY_GTK_THEME, () => {
+ interfaceSettings.connect(`changed::${KEY_GTK_THEME}`, () => {
let value = interfaceSettings.get_string(KEY_GTK_THEME);
if (value == HIGH_CONTRAST_THEME) {
highContrast.setToggleState(true);
this._queueSyncMenuVisibility();
});
- interfaceSettings.connect('changed::' + KEY_ICON_THEME, () => {
+ interfaceSettings.connect(`changed::${KEY_ICON_THEME}`, () => {
let value = interfaceSettings.get_string(KEY_ICON_THEME);
if (value != HIGH_CONTRAST_THEME)
iconTheme = value;
settings.reset(KEY_TEXT_SCALING_FACTOR);
});
- settings.connect('changed::' + KEY_TEXT_SCALING_FACTOR, () => {
+ settings.connect(`changed::${KEY_TEXT_SCALING_FACTOR}`, () => {
let factor = settings.get_double(KEY_TEXT_SCALING_FACTOR);
let active = (factor > 1.0);
widget.setToggleState(active);
this.add_child(this._hbox);
this._a11ySettings = new Gio.Settings({ schema_id: MOUSE_A11Y_SCHEMA });
- this._a11ySettings.connect('changed::' + KEY_DWELL_CLICK_ENABLED, this._syncMenuVisibility.bind(this));
- this._a11ySettings.connect('changed::' + KEY_DWELL_MODE, this._syncMenuVisibility.bind(this));
+ this._a11ySettings.connect(`changed::${KEY_DWELL_CLICK_ENABLED}`, this._syncMenuVisibility.bind(this));
+ this._a11ySettings.connect(`changed::${KEY_DWELL_MODE}`, this._syncMenuVisibility.bind(this));
this._deviceManager = Clutter.DeviceManager.get_default();
this._deviceManager.connect('ptr-a11y-dwell-click-type-changed', this._updateClickType.bind(this));
return this.id;
if (engineDesc.variant && engineDesc.variant.length > 0)
- return engineDesc.layout + '+' + engineDesc.variant;
+ return `${engineDesc.layout}+${engineDesc.variant}`;
else
return engineDesc.layout;
}
try {
props = conn.call_finish(result).deep_unpack()[0];
} catch (e) {
- log('Could not get properties from ' + this._BUS_NAME);
+ log(`Could not get properties from ${this._BUS_NAME}`);
return;
}
let layouts = props['X11Layout'].unpack();
for (let i = 0; i < layouts.length && !!layouts[i]; i++) {
let id = layouts[i];
if (variants[i])
- id += '+' + variants[i];
+ id += `+${variants[i]}`;
sourcesList.push({ type: INPUT_SOURCE_TYPE_XKB, id: id });
}
return sourcesList;
this._KEY_PER_WINDOW = 'per-window';
this._settings = new Gio.Settings({ schema_id: this._DESKTOP_INPUT_SOURCES_SCHEMA });
- this._settings.connect('changed::' + this._KEY_INPUT_SOURCES, this._emitInputSourcesChanged.bind(this));
- this._settings.connect('changed::' + this._KEY_KEYBOARD_OPTIONS, this._emitKeyboardOptionsChanged.bind(this));
- this._settings.connect('changed::' + this._KEY_PER_WINDOW, this._emitPerWindowChanged.bind(this));
+ this._settings.connect(`changed::${this._KEY_INPUT_SOURCES}`, this._emitInputSourcesChanged.bind(this));
+ this._settings.connect(`changed::${this._KEY_KEYBOARD_OPTIONS}`, this._emitKeyboardOptionsChanged.bind(this));
+ this._settings.connect(`changed::${this._KEY_PER_WINDOW}`, this._emitPerWindowChanged.bind(this));
}
_getSourcesList(key) {
let description = xkbLayout;
if (xkbVariant.length > 0)
- description = description + '\t' + xkbVariant;
+ description = `${description}\t${xkbVariant}`;
Util.spawn(['gkbd-keyboard-display', '-l', description]);
}
super();
this._settings = new Gio.Settings({ schema_id: LOCATION_SCHEMA });
- this._settings.connect('changed::' + ENABLED,
+ this._settings.connect(`changed::${ENABLED}`,
this._onMaxAccuracyLevelChanged.bind(this));
- this._settings.connect('changed::' + MAX_ACCURACY_LEVEL,
+ this._settings.connect(`changed::${MAX_ACCURACY_LEVEL}`,
this._onMaxAccuracyLevelChanged.bind(this));
this._indicator = this._addIndicator();
this._onAuthDone = onAuthDone;
let appSystem = Shell.AppSystem.get_default();
- this._app = appSystem.lookup_app(this.desktopId + ".desktop");
+ this._app = appSystem.lookup_app(`${this.desktopId}.desktop`);
if (this._app == null || this._permStoreProxy == null) {
this._completeAuth();
}
_getSignalIcon() {
- return 'network-cellular-signal-' + signalToIcon(this._mobileDevice.signal_quality) + '-symbolic';
+ return `network-cellular-signal-${signalToIcon(this._mobileDevice.signal_quality)}-symbolic`;
}
};
if (this._ap.mode == NM80211Mode.ADHOC)
return 'network-workgroup-symbolic';
else
- return 'network-wireless-signal-' + signalToIcon(this._ap.strength) + '-symbolic';
+ return `network-wireless-signal-${signalToIcon(this._ap.strength)}-symbolic`;
}
});
}
if (this._canReachInternet())
- return 'network-wireless-signal-' + signalToIcon(ap.strength) + '-symbolic';
+ return `network-wireless-signal-${signalToIcon(ap.strength)}-symbolic`;
else
return 'network-wireless-no-route-symbolic';
}
} catch (e) { }
});
} else {
- log('Invalid result from portal helper: ' + result);
+ log(`Invalid result from portal helper: ${result}`);
}
}
new PortalHelperProxy(Gio.DBus.session, 'org.gnome.Shell.PortalHelper',
'/org/gnome/Shell/PortalHelper', (proxy, error) => {
if (error) {
- log('Error launching the portal helper: ' + error);
+ log(`Error launching the portal helper: ${error}`);
return;
}
super();
this._desktopSettings = new Gio.Settings({ schema_id: 'org.gnome.desktop.interface' });
- this._desktopSettings.connect('changed::' + SHOW_BATTERY_PERCENTAGE,
+ this._desktopSettings.connect(`changed::${SHOW_BATTERY_PERCENTAGE}`,
this._sync.bind(this));
this._indicator = this._addIndicator();
this._slider = new Slider.Slider(0);
this._soundSettings = new Gio.Settings({ schema_id: 'org.gnome.desktop.sound' });
- this._soundSettings.connect('changed::' + ALLOW_AMPLIFIED_VOLUME_KEY, this._amplifySettingsChanged.bind(this));
+ this._soundSettings.connect(`changed::${ALLOW_AMPLIFIED_VOLUME_KEY}`, this._amplifySettingsChanged.bind(this));
this._amplifySettingsChanged();
this._slider.connect('value-changed', this._sliderChanged.bind(this));
function _addHandler(target, params, name, handler) {
if (params[name]) {
let oldHandler = params[name];
- let oldScope = params[name + 'Scope'];
- let oldParams = params[name + 'Params'];
+ let oldScope = params[`${name}Scope`];
+ let oldParams = params[`${name}Params`];
let eventScope = oldScope ? oldScope : target;
params[name] = () => {